home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / Eudora 1.3.1 / source / menu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-16  |  18.9 KB  |  726 lines  |  [TEXT/MPS ]
  1. #define FILE_NUM 11
  2. /* Copyright (c) 1990-1992 by the University of Illinois Board of Trustees */
  3. #pragma load EUDORA_LOAD
  4. #pragma segment Menu
  5.     void SetQItemText(MyWindowPtr win);
  6.     Boolean DoIndependentMenu(int menu,int item,short modifiers);
  7.     Boolean DoDependentMenu(WindowPtr topWin,int menu,int item,short modifiers);
  8.     void BuildWindowsMenu(void);
  9.     void SetCheckItem(void);
  10.     Boolean SameSettingsFile(short vRef,long dirId,UPtr name);
  11.     void InsertRecipient(MyWindowPtr win, short which,Boolean all);
  12. #define TICKS2MINS 3600
  13.  
  14. /**********************************************************************
  15.  * DoMenu - handle a menu selection
  16.  **********************************************************************/
  17. void DoMenu(WindowPtr topWin,long selection,short modifiers)
  18. {
  19.     short menu = (selection >> 16) & 0xffff;
  20.     short item = selection & 0xffff;
  21.     
  22.     if (LOG_MENU&LogLevel)
  23.     {
  24.         Str31 mStr,iStr;
  25.         PCopy(mStr,"\pnone");
  26.         PCopy(iStr,mStr);
  27.         if (menu)
  28.         {
  29.             PCopy(mStr,(*GetMHandle(menu))->menuData);
  30.             if (item) MyGetItem(GetMHandle(menu),item,iStr);
  31.         }
  32.         ComposeLogS(LOG_MENU,nil,"\p%p %p",mStr,iStr);
  33.     }
  34.     if (menu && item)
  35.     {
  36.         PushCursor(watchCursor);
  37.         if (!(topWin && ((WindowPeek)topWin)->windowKind==dialogKind &&
  38.                     menu==EDIT_MENU && DoModelessEdit(topWin,item)) &&
  39.                 !DoDependentMenu(topWin,menu,item,modifiers) &&
  40.                 !DoIndependentMenu(menu,item,modifiers))
  41.                 /*NotImplemented()*/;
  42.         PopCursor();
  43.   }
  44.     HiliteMenu(0);
  45. }
  46.  
  47. /**********************************************************************
  48.  * DoIndependentMenu - handle a menu selection that does not depend on
  49.  * what window is frontmost.    returns True if selection handled, False else
  50.  **********************************************************************/
  51. Boolean DoIndependentMenu(int menu,int item,short modifiers)
  52. {
  53.     Str255 scratch;
  54.     short function;
  55.     long dirId;
  56.     MenuHandle mh=GetMHandle(menu);
  57.     MyWindowPtr newWin;
  58.     MyWindowPtr win=FrontWindow();
  59.     TEHandle teh = WinTEH(win);
  60.     HFileInfo hfi;
  61.     
  62.     switch (menu)
  63.     {
  64.         case APPLE_MENU:
  65.             switch (item)
  66.             {
  67.                 case APPLE_ABOUT_ITEM:
  68.                     DoAboutUIUCmail();
  69.                     return(True);
  70.                 default:
  71.                     GetItem(mh,item,scratch);
  72.                     (void) OpenDeskAcc(scratch);
  73.                     return(True);
  74.             }
  75.             break;
  76.  
  77.         case EDIT_MENU:
  78.             switch (item)
  79.             {
  80.                 case EDIT_SHOW_ITEM:
  81.                     ShowInsertion(win,InsertAny);
  82.                     return(True);
  83.                     break;
  84.                 case EDIT_FINISH_ITEM:
  85.                     if (IsMyWindow(win))
  86.                         FinishAlias(win,(modifiers&optionKey)!=0,False);
  87.                     return(True);
  88.                     break;
  89.                 case EDIT_UNDO_ITEM:
  90.                     DoUndo();
  91.                     SelectWindow(Undo.win);
  92.                     ShowInsertion(Undo.win,InsertAny);
  93.                     return(True);
  94.                     break;
  95.                 case EDIT_SELECT_ITEM:
  96.                     {
  97.                         if (teh)
  98.                         {
  99.                             NoScrollTESetSelect(0,INFINITY,teh);
  100.                             win->hasSelection = (*teh)->selStart != (*teh)->selEnd;
  101.                             return(True);
  102.                         }
  103.                     }
  104.                     break;
  105.             }
  106.             break;
  107.  
  108.         case FILE_MENU:
  109.             switch (item)
  110.             {
  111.                 case FILE_NEW_ITEM:
  112.                     (void) OpenText(0,"",nil,True,GetRString(scratch,UNTITLED));
  113.                     return(True);
  114.                     break;
  115.                 case FILE_OPEN_ITEM:
  116.                     {
  117.                         Str31 name;
  118.                         long dirId;
  119.                         short vRef;
  120.                         SFTypeList tl;
  121.                         short numTypes;
  122.                         if (modifiers&optionKey)
  123.                             numTypes = -1;
  124.                         else
  125.                         {
  126.                             numTypes = 2;
  127.                             tl[0] = 'TEXT';
  128.                             tl[1] = SETTINGS_TYPE;
  129.                         }
  130.                         if (MySFGetFile(nil,&dirId,&vRef,name,numTypes,tl))
  131.                         {
  132.                             FInfo info;
  133.                             short err;
  134.                             if (err=HGetFInfo(vRef,0L,name,&info))
  135.                                 FileSystemError(TEXT_READ,name,err);
  136.                             else if (info.fdType==SETTINGS_TYPE && info.fdCreator==CREATOR)
  137.                             {
  138.                                 if (!SameSettingsFile(vRef,0L,name))
  139.                                     OpenNewSettings(vRef,0L,name);
  140.                             }
  141.                             else
  142.                                 OpenText(vRef,name,nil,True,nil);
  143.                         }
  144.                         return(True);
  145.                     }
  146.                     break;
  147.                 case FILE_CLOSE_ITEM:
  148.                     if (modifiers&optionKey)
  149.                     {
  150.                         CloseAll();
  151.                         return(True);
  152.                     }
  153.                     else if (IsMyWindow(FrontWindow()))
  154.                     {
  155.                         CloseMyWindow(FrontWindow());
  156.                         return(True);
  157.                     }
  158.                     else
  159.                         return(False);
  160.                     break;
  161.                 case FILE_SEND_ITEM:
  162.                     DoSendQueue();
  163.                     return(True);
  164.                 case FILE_CHECK_ITEM:
  165.                     CheckForMail((modifiers&shiftKey)!=0);
  166.                     return(True);
  167.                 case FILE_PAGE_ITEM:
  168.                     DoPageSetup();
  169.                     return(True);
  170.                 case FILE_QUIT_ITEM:
  171.                     DoQuit();
  172.                     return(True);
  173.                 case FILE_BEHIND_ITEM:
  174.                     if (FrontWindow()) SendBehind(FrontWindow(),nil);
  175.                     return(True);
  176.             }
  177.             break;
  178.         case NEW_TO_HIER_MENU:
  179.             if (newWin=DoComposeNew(item))
  180.             {
  181.                 MessType **messH =(MessType **)newWin->qWindow.refCon;
  182.                 ShowMyWindow(newWin);
  183.             }
  184.             return(True);
  185.             break;
  186.             
  187.         case FIND_HIER_MENU:
  188.             DoFind(item);
  189.             return(True);
  190.             break;
  191.         
  192.         case MESSAGE_MENU:
  193.             switch(item)
  194.             {
  195.                 case MESSAGE_NEW_ITEM:
  196.                 if (newWin=DoComposeNew(0))
  197.                     ShowMyWindow(newWin);
  198.                 return(True);
  199.                 break;
  200.             }
  201.             break;
  202.             
  203.         case MAILBOX_MENU:
  204.             MyGetItem(mh,item,scratch);
  205.             (void) GetMailbox(MyDirId,scratch,True);
  206.             return(True);
  207.             break;
  208.  
  209.         case SPECIAL_MENU:
  210.             switch (item)
  211.             {
  212.                 case SPECIAL_ALIASES_ITEM:
  213.                     OpenAliases();
  214.                     return(True);
  215.                 case SPECIAL_NPREFS_ITEM:
  216.                     DoNetPreferences();
  217.                     return(True);
  218.                 case SPECIAL_UPREFS_ITEM:
  219.                     DoUserPreferences();
  220.                     return(True);
  221.                 case SPECIAL_SIG_ITEM:
  222.                 {
  223.                     short shortjunk; long longjunk;
  224.                     if (!GetFileByRef(SettingsRefN,&shortjunk,&longjunk,scratch))
  225.                         (void) OpenText(MyVRef,scratch,nil,
  226.                                                     True,GetRString(scratch+64,SIGNATURE));
  227.                     return(True);
  228.                 }
  229.                 case SPECIAL_CTB_ITEM:
  230.                     (void) InitCTB(True);
  231.                     return(True);
  232.                 case SPECIAL_PH_ITEM:
  233.                     OpenPh();
  234.                     return(True);
  235.                 case SPECIAL_FORGET_ITEM:
  236. #ifndef KERBEROS
  237.                     InvalidatePasswords(False,False);
  238. #else
  239.                     {
  240.                                 extern void         forgetsession(char *name, char *inst, char *realm);
  241.                                 Str63 userName, args;
  242.                                 char instance[INST_SZ];
  243.                                 char realm[REALM_SZ];
  244.                                 
  245.                                 GetPOPInfo(userName,args);
  246.                                 p2cstr(userName);
  247.                                 instance[0] = 0;
  248.                                 realm[0] = 0;
  249.                                 if(!krb_get_lrealm(realm, 1)) {
  250.                                                 forgetsession((char *)userName, instance, realm);
  251.                                                 }
  252.                                 }
  253.                                 POPSecure = False;
  254. #endif
  255.                     return(True);
  256.                 case SPECIAL_TRASH_ITEM:
  257.                     EmptyTrash();
  258.                     return(True);
  259.                 case SPECIAL_COMPACT_ITEM:
  260.                     RememberOpenWindows();
  261.                     GetRString(scratch,TOC_SUFFIX);
  262.                     DoCompact(MyDirId,&hfi,*scratch);
  263.                     if (!FrontWindow()) RecallOpenWindows();
  264.                     return(True);
  265.                 case SPECIAL_ADD_TO_ITEM:
  266.                     AddSelectionAsTo();
  267.                     return(True);
  268.                 case SPECIAL_MAILBOX_ITEM:
  269.                     OpenMBWin();
  270.                     return(True);
  271.                 case SPECIAL_CHANGE_ITEM:
  272.                     ChangePassword();
  273.                     return(True);
  274.             }
  275.             break;
  276.         case REMOVE_TO_HIER_MENU:
  277.             {
  278.                 short hM;
  279.                 for (hM=NEW_TO_HIER_MENU;hM<=INSERT_TO_HIER_MENU;hM++)
  280.                     DelMenuItem(GetMHandle(hM),item);
  281.                 ToMenusChanged();
  282.             }
  283.             return(True);
  284.             break;
  285.         case INSERT_TO_HIER_MENU:
  286.             if (IsMyWindow(FrontWindow()))
  287.                 InsertRecipient(FrontWindow(),item,(modifiers&optionKey)!=0);
  288.             return(True);
  289.             break;
  290.         case WINDOW_MENU:
  291.             HandleWindowChoice(item);
  292.             break;
  293. #ifdef DEBUG
  294.         case DEBUG_MENU:
  295.             {
  296.                 short theMark;
  297.                 GetItemMark(mh,item,&theMark);
  298.                 if (theMark)
  299.                 {
  300.                     SetItemMark(mh,item,0);
  301.                     BugFlags &= ~(1L<<(item-1));
  302.                 }
  303.                 else
  304.                 {
  305.                     SetItemMark(mh,item,checkMark);
  306.                     BugFlags |= (1L<<(item-1));
  307.                 }
  308.                 return(True);
  309.             }
  310.             break;
  311. #endif
  312.         default:
  313.             dirId = (*BoxMap)[menu % MAX_BOX_LEVELS];
  314.             function = (menu-1)/MAX_BOX_LEVELS;
  315.             switch (function)
  316.             {
  317.                 case MAILBOX:
  318.                     MyGetItem(mh,item,scratch);
  319.                     (void) GetMailbox(dirId,scratch,True);
  320.                     return(True);
  321.                 case TRANSFER:
  322.                     break;
  323.             }
  324.     }
  325.  
  326.     return(False);
  327. }
  328.  
  329. /**********************************************************************
  330.  * DoDependentMenu - handle a menu selection whose behavior depends
  331.  * on what window is frontmost.  returns True if item handled, False else
  332.  **********************************************************************/
  333. Boolean DoDependentMenu(WindowPtr topWin,int menu,int item,short modifiers)
  334. {
  335.     if (topWin != nil)
  336.     {
  337.         if (((WindowPeek)topWin)->windowKind < 0)
  338.         {
  339.             switch (menu)
  340.             {
  341.                 case EDIT_MENU:
  342.                     switch(item)
  343.                     {
  344.                         case EDIT_UNDO_ITEM:
  345.                         case EDIT_CUT_ITEM:
  346.                         case EDIT_COPY_ITEM:
  347.                         case EDIT_PASTE_ITEM:
  348.                             (void) SystemEdit(item-1);
  349.                             return(True);
  350.                         case EDIT_CLEAR_ITEM:
  351.                             (void) SystemEdit(item-2);
  352.                             return(True);
  353.                     }
  354.                     break;
  355.                 case FILE_MENU:
  356.                     if (item==FILE_CLOSE_ITEM)
  357.                     {
  358.                         CloseDeskAcc(((WindowPeek)topWin)->windowKind);
  359.                         return(True);
  360.                     }
  361.                     break;
  362.             }
  363.         }
  364.         else if ((((WindowPeek)topWin)->windowKind>userKind ||
  365.              ((WindowPeek)topWin)->windowKind==dialogKind) &&
  366.             ((MyWindowPtr)topWin)->menu)
  367.             return((*((MyWindowPtr)topWin)->menu)(topWin,menu,item,modifiers));
  368.     }
  369.     return(False);
  370. }
  371.  
  372. /**********************************************************************
  373.  * EnableMenuItems - enable menu items, depending on the type and state of
  374.  * the topmost window
  375.  **********************************************************************/
  376. void EnableMenuItems(void)
  377. {
  378.     int kind;
  379.     Boolean dirty = False, selection = False;
  380.     MenuHandle mh;
  381.     WindowPtr qdWin = FrontWindow();
  382.     MyWindowPtr mw = (MyWindowPtr)qdWin;
  383.     Boolean hasTx=False, ro=False;
  384.     Boolean scrapFull = InfoScrap()->scrapSize > 0;
  385.     Boolean outside = False;
  386.     Boolean curMessage = False;
  387.     Boolean force = False;
  388.     Boolean compRo = False;
  389.     Str63 txt;
  390.  
  391.     /*
  392.      * figure out just what's in front
  393.      */
  394.     if (qdWin==(WindowPtr)(-1)) {qdWin = nil; force = True;}
  395.     if (qdWin==nil)
  396.     {
  397.         kind=0;
  398.         dirty=False; selection=False; hasTx=False; ro = True;
  399.     }
  400.     else
  401.     {
  402.         kind = ((WindowPeek)qdWin)->windowKind;
  403.         if (kind >= userKind)
  404.         {
  405.             dirty = mw->isDirty;
  406.             selection = mw->hasSelection;
  407.             hasTx = WinTEH(mw)!=nil;
  408.             ro = mw->ro;
  409.             if (kind==COMP_WIN)
  410.                 compRo = SumOf(Win2MessH(mw))->state==SENT;
  411.             
  412.         }
  413.     }
  414.     
  415.     /*
  416.      * enable menus accordingly, if anything has changed
  417.      */
  418.     curMessage = kind==MESS_WIN || kind==COMP_WIN ||
  419.                                 ((kind==MBOX_WIN || kind==CBOX_WIN) && selection);
  420.     outside = curMessage && (kind==MESS_WIN || kind==MBOX_WIN);
  421.     mh = GetMHandle(FILE_MENU);
  422.     EnableIf(mh,FILE_CLOSE_ITEM,kind!=0);
  423.     EnableIf(mh,FILE_SAVE_ITEM,dirty && kind!=MBOX_WIN);
  424.     EnableIf(mh,FILE_SAVE_AS_ITEM,curMessage||kind==TEXT_WIN);
  425.     EnableIf(mh,FILE_PRINT_ITEM,curMessage||kind==PH_WIN||kind==TEXT_WIN);
  426.     EnableIf(mh,FILE_PRINT_SELECT_ITEM,selection && hasTx && (curMessage||kind==PH_WIN||kind==TEXT_WIN));
  427.     EnableIf(mh,FILE_BEHIND_ITEM,mw!=nil);
  428.     
  429.     mh = GetMHandle(EDIT_MENU);
  430.     if (kind<userKind)
  431.     {
  432.         Str63 scratch;
  433.         GetRString(scratch,UNDO);
  434.         SetItem(mh,EDIT_UNDO_ITEM,scratch);
  435.         EnableIf(mh,EDIT_UNDO_ITEM,mw!=nil);
  436.     }
  437.     else
  438.         SetUndoMenu();
  439.     EnableIf(mh,EDIT_CUT_ITEM,mw && (kind<userKind || selection && !ro));
  440.     EnableIf(mh,EDIT_COPY_ITEM,mw && (kind<userKind || selection));
  441.     EnableIf(mh,EDIT_PASTE_ITEM,mw && (scrapFull &&
  442.             (!ro && hasTx) || kind<userKind));
  443.     EnableIf(mh,EDIT_QUOTE_ITEM,scrapFull && !ro && hasTx && kind==COMP_WIN);
  444.     EnableIf(mh,EDIT_CLEAR_ITEM,mw && (kind<userKind || selection &&
  445.                                                                 (!ro || kind==COMP_WIN)));
  446.     EnableIf(mh,EDIT_WRAP_ITEM,mw && selection && !ro && (kind==TEXT_WIN || kind==COMP_WIN));
  447.     EnableIf(mh,EDIT_SELECT_ITEM,mw!=nil);
  448.     EnableIf(mh,EDIT_SHOW_ITEM,hasTx);
  449.     EnableIf(mh,EDIT_INSERT_TO_ITEM,hasTx&&!ro);
  450.     EnableIf(mh,EDIT_SORT_ITEM,kind==MBOX_WIN||kind==CBOX_WIN);
  451.     EnableIf(mh,EDIT_FINISH_ITEM,hasTx&&!ro);
  452.     
  453.     EnableFindMenu();
  454.             
  455.     mh = GetMHandle(MESSAGE_MENU);
  456.     GetRString(txt,PrefIsSet(PREF_REPLY_ALL)?REPLY_ALL:REPLY);
  457.     SetItem(mh,MESSAGE_REPLY_ITEM,txt);
  458.     EnableIf(mh,MESSAGE_REPLY_ITEM,outside);
  459.     EnableIf(mh,MESSAGE_FORWARD_ITEM,kind==MESS_WIN || kind==COMP_WIN
  460.                                     || (kind==MBOX_WIN || kind==CBOX_WIN)&&selection);
  461.     EnableIf(mh,MESSAGE_REDISTRIBUTE_ITEM,outside);
  462.     EnableIf(mh,MESSAGE_SALVAGE_ITEM,kind==MESS_WIN || kind==COMP_WIN
  463.                                     || (kind==MBOX_WIN || kind==CBOX_WIN)&&selection);
  464.     EnableIf(mh,MESSAGE_REPLY_TO_ITEM,outside);
  465.     EnableIf(mh,MESSAGE_FORWARD_TO_ITEM,kind==MESS_WIN || kind==COMP_WIN
  466.                                     || (kind==MBOX_WIN || kind==CBOX_WIN)&&selection);
  467.     EnableIf(mh,MESSAGE_REDIST_TO_ITEM,outside);
  468.     EnableIf(mh,MESSAGE_QUEUE_ITEM,
  469.                                         kind==COMP_WIN || kind==CBOX_WIN&&selection);
  470.     EnableIf(mh,MESSAGE_MOD_Q_ITEM,
  471.                                         kind==COMP_WIN || kind==CBOX_WIN&&selection);
  472.     EnableIf(mh,MESSAGE_DELETE_ITEM,curMessage);
  473.     EnableIf(mh,MESSAGE_ATTACH_ITEM,kind==COMP_WIN&&!compRo);
  474.         
  475.     EnableIf(GetMHandle(TRANSFER_MENU),0,curMessage);
  476.  
  477.     mh = GetMHandle(SPECIAL_MENU);
  478.     EnableIf(mh,SPECIAL_ADD_TO_ITEM,hasTx && selection);
  479.     EnableIf(mh,SPECIAL_CTB_ITEM,UseCTB);
  480.     EnableIf(mh,SPECIAL_FORGET_ITEM,POPSecure || *Password || *SecondPass);
  481.     EnableIf(mh,SPECIAL_MAKE_NICK_ITEM,curMessage||CanMakeNick());
  482.     
  483.     /*
  484.      * this is a maverick menu item
  485.      */
  486.     EnableIf(GetMHandle(FILE_MENU),FILE_SEND_ITEM,SendQueue>0);
  487.     if (kind==COMP_WIN || kind==CBOX_WIN) SetQItemText(mw);
  488.         
  489.     /*
  490.      * check the mailbox represented by the topmost window
  491.      */
  492.     CheckBox(qdWin);
  493.     
  494.     /*
  495.      * build the Windows menu
  496.      */
  497.     BuildWindowsMenu();
  498.     
  499.     /*
  500.      * and the mailbox check item...
  501.      */
  502.     SetCheckItem();
  503. }
  504.  
  505. /**********************************************************************
  506.  * EnableMenus - enable menus, depending on the type and state of
  507.  * the topmost window
  508.  **********************************************************************/
  509. void EnableMenus(WindowPtr qdWin)
  510. {
  511.     Boolean mBar = False;
  512.     MyWindowPtr mw = (MyWindowPtr)qdWin;
  513.     Boolean curMessage = False;
  514.     short kind;
  515.  
  516.     /*
  517.      * figure out just what's in front
  518.      */
  519.     if (qdWin!=nil)
  520.     {
  521.         kind = ((WindowPeek)qdWin)->windowKind;
  522.         if (kind >= userKind)
  523.         {
  524.             curMessage = kind==MESS_WIN || kind==COMP_WIN ||
  525.                                  ((kind==MBOX_WIN || kind==CBOX_WIN) && mw->hasSelection);
  526.         }
  527.     }
  528.     
  529.     /*
  530.      * enable menus accordingly, if anything has changed
  531.      */
  532.     mBar=EnableIf(GetMHandle(FILE_MENU),0,True)||mBar;
  533.     mBar=EnableIf(GetMHandle(EDIT_MENU),0,True)||mBar;
  534.     mBar=EnableIf(GetMHandle(MESSAGE_MENU),0,True)||mBar;
  535.     mBar=EnableIf(GetMHandle(TRANSFER_MENU),0,curMessage)||mBar;
  536.     mBar=EnableIf(GetMHandle(SPECIAL_MENU),0,True)||mBar;
  537.     mBar=EnableIf(GetMHandle(WINDOW_MENU),0,qdWin!=nil)||mBar;
  538.     
  539.     /*
  540.      * draw the menu bar if that's necessary
  541.      */
  542.     if (mBar) DrawMenuBar();
  543. }
  544.  
  545. /************************************************************************
  546.  * SetQItemText - set the text of the Queue For Delivery menu item
  547.  ************************************************************************/
  548. void SetQItemText(MyWindowPtr win)
  549. {
  550.     TOCHandle tocH = nil;
  551.     int sumNum = -1;
  552.     
  553.     if (win->qWindow.windowKind==COMP_WIN)
  554.     {
  555.         tocH = (*(MessType **)win->qWindow.refCon)->tocH;
  556.         sumNum = (*(MessType **)win->qWindow.refCon)->sumNum;
  557.     }
  558.     else if (win->qWindow.windowKind==CBOX_WIN)
  559.     {
  560.         tocH = (TOCType **)win->qWindow.refCon;
  561.         for (sumNum=0;sumNum<(*tocH)->count;sumNum++)
  562.             if ((*tocH)->sums[sumNum].selected) break;
  563.     }
  564.     if (tocH && sumNum >= 0)
  565.     {
  566.         if ((*tocH)->sums[sumNum].state==SENT)
  567.         {
  568.             DisableItem(GetMHandle(MESSAGE_MENU),MESSAGE_QUEUE_ITEM);
  569.             DisableItem(GetMHandle(MESSAGE_MENU),MESSAGE_MOD_Q_ITEM);
  570.         }
  571.         else
  572.         {
  573.             EnableItem(GetMHandle(MESSAGE_MENU),MESSAGE_QUEUE_ITEM);
  574.             EnableItem(GetMHandle(MESSAGE_MENU),MESSAGE_MOD_Q_ITEM);
  575.         }
  576.     }
  577. }
  578.  
  579. /**********************************************************************
  580.  * CheckBox - check the topmost mailbox, and disable in transfer menu
  581.  **********************************************************************/
  582. void CheckBox(MyWindowPtr win)
  583. {
  584.     TOCHandle tocH;
  585.     Str31 name;
  586.     short n;
  587.     
  588.     if (CheckedMenu && CheckedItem)
  589.     {
  590.         SetItemMark(CheckedMenu,CheckedItem,0);
  591.         CheckedMenu = nil;
  592.     }
  593.         
  594.     if (!IsMyWindow(win)) return;
  595.     if (win->qWindow.windowKind==MBOX_WIN)
  596.         tocH = (TOCHandle) win->qWindow.refCon;
  597.     else if (win->qWindow.windowKind==MESS_WIN)
  598.         tocH = (*(MessHandle) win->qWindow.refCon)->tocH;
  599.     else
  600.     {
  601.         if (win->qWindow.windowKind==CBOX_WIN ||
  602.                      win->qWindow.windowKind==COMP_WIN)
  603.             SetItemMark(CheckedMenu=GetMHandle(MAILBOX_MENU),
  604.                                 CheckedItem=MAILBOX_OUT_ITEM,checkMark);
  605.         return;
  606.     }
  607.     
  608.     if ((*tocH)->which==IN)
  609.         SetItemMark(CheckedMenu=GetMHandle(MAILBOX_MENU),
  610.                                 CheckedItem=MAILBOX_IN_ITEM,checkMark);
  611.     else if ((*tocH)->which==TRASH)
  612.         SetItemMark(CheckedMenu=GetMHandle(MAILBOX_MENU),
  613.                                 CheckedItem=MAILBOX_TRASH_ITEM,checkMark);
  614.     else
  615.     {
  616.         for (n=0;;n++) if ((*BoxMap)[n]==(*tocH)->dirId) break;
  617.         PCopy(name,(*tocH)->name);
  618.         CheckedMenu=GetMHandle(n?n:MAILBOX_MENU);
  619.         CheckedItem=FindItemByName(CheckedMenu,name);
  620.         SetItemMark(CheckedMenu,CheckedItem,checkMark);
  621.     }
  622. }
  623.  
  624. /************************************************************************
  625.  * EnableIf - enable a menu item based on an expression.
  626.  * Returns True is the menu bar needs to be redrawn.
  627.  ************************************************************************/
  628. Boolean EnableIf(MenuHandle mh, short item, Boolean expr)
  629. { 
  630.     Boolean result; 
  631.  
  632.     expr = expr ? 1 : 0;                    /* normalize */
  633.     result = item==0 && ((((*mh)->enableFlags&1)==1)!=(expr));
  634.     if (expr)
  635.         EnableItem(mh,item);
  636.     else
  637.         DisableItem(mh,item);
  638.     return (result);
  639. }
  640.  
  641. /************************************************************************
  642.  * SetCheckItem - put the time of the next mail check in the Check Mail
  643.  * item.
  644.  ************************************************************************/
  645. void SetCheckItem(void)
  646. {
  647.     Str63 item;
  648.     unsigned ivalTicks;
  649.     short n;
  650.     
  651.     GetRString(item,CHECK_MAIL);
  652.     if (CheckTicks && (ivalTicks=TICKS2MINS*GetRLong(PREF_STRN+PREF_INTERVAL)))
  653.     {
  654.         PCat(item,"\p ");
  655.         n = *item+1;
  656.         IUTimeString(LocalDateTime()+(CheckTicks+ivalTicks-TickCount())/60,
  657.                                  False,item+n);
  658.         item[0] += item[n]+1;
  659.         item[n] = '(';
  660.         PCatC(item,')');
  661.     }
  662.     SetItem(GetMHandle(FILE_MENU),FILE_CHECK_ITEM,item);
  663. }
  664.  
  665. /************************************************************************
  666.  * InsertRecipient - insert a given recipient in a window
  667.  ************************************************************************/
  668. void InsertRecipient(MyWindowPtr win, short which,Boolean all)
  669. {
  670.     UPtr spot;
  671.     Str63 scratch;
  672.     
  673.     Undo.didClick=True;
  674.     InsertCommaIfNeedBe(win);
  675.     MyGetItem(GetMHandle(NEW_TO_HIER_MENU),which,scratch);
  676.     for (spot=scratch+1;spot<scratch+*scratch+1;spot++)
  677.         TESomething(win,TEKEY,*spot,0);
  678.     if (all) FinishAlias(win,all,False);
  679. }
  680.  
  681.  
  682. /************************************************************************
  683.  * BuildWindowsMenu
  684.  ************************************************************************/
  685. void BuildWindowsMenu(void)
  686. {
  687.     Str255 title;
  688.     MyWindowPtr win;
  689.     MenuHandle mh = GetMHandle(WINDOW_MENU);
  690.     
  691.     if (mh)
  692.     {
  693.         TrashMenu(mh,1);
  694.         for (win=FrontWindow();win;win=win->qWindow.nextWindow)
  695.         if (win->qWindow.visible)
  696.             {
  697.                 GetWTitle(win,title);
  698.                 if (*title>31)
  699.                 {
  700.                     *title = 31;
  701.                     title[31] = '…';
  702.                 }
  703.                 MyAppendMenu(mh,title);
  704.                 if (win->qWindow.windowKind==COMP_WIN)
  705.                     SetItemStyle(mh,CountMItems(mh),italic);
  706.             }
  707.     }
  708. }
  709.  
  710.  
  711. #pragma segment Ends
  712. /************************************************************************
  713.  *
  714.  ************************************************************************/
  715. Boolean SameSettingsFile(short vRef,long dirId,UPtr name)
  716. {
  717. #pragma unused(dirId)
  718.     Str63 curName;
  719.     short curVRef;
  720.     long curDirId;
  721.     
  722.     if (GetFileByRef(SettingsRefN,&curVRef,&curDirId,curName)) return(False);
  723.     
  724.     return(MyVRef == vRef && EqualString(name,curName,False,True));
  725. }
  726.